{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "atari_space_invaders.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true,
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "name": "python3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/letianzj/QuantResearch/blob/master/ml/atari_space_invaders.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HwOjJMZUHsp3"
      },
      "source": [
        "(Use Open in Colab button above to watch the embedded videos of agent playing Space-Invader)\n",
        "\n",
        "## Introduction\n",
        "\n",
        "[OpenAI Gym](https://gym.openai.com/) provides a list of test environments to help develop reinforcement learning algorithms. This [leaderboard](https://github.com/cshenton/atari-leaderboard) keeps records from both human and machine players.\n",
        "\n",
        "A gym environment is a __Markov Decision Process__ of tuple $<S, A, P, R, \\gamma>$ that includes the following.\n",
        "* **Agent** -- The robot player to be trained.\n",
        "* **Environment** -- Atari game.\n",
        "* **observation space** -- The current state of the environment that the robot observes.\n",
        "* **action space** -- The choice that the robot takes at each step.\n",
        "* **Reward** -- Game score.\n",
        "* **Policy** -- How the robot plays.\n",
        "\n",
        "This notebook illustrates how to train [Atari Space-Invaders](https://gym.openai.com/envs/SpaceInvaders-v0/) using [TF-Agents](https://www.tensorflow.org/agents/tutorials/1_dqn_tutorial). It follows the official [TF-Agents DQN Tutorial](https://www.tensorflow.org/agents/tutorials/1_dqn_tutorial) and [Hands-on Machine Learning by Aurélien Géron 2019](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nANyrWwgE1yT"
      },
      "source": [
        "## Setup\n",
        "\n",
        "Install required packages and Roms."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jr3P9fWZIXBN"
      },
      "source": [
        "import warnings\n",
        "warnings.filterwarnings('ignore')"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "2kBhJbmqLz63",
        "outputId": "d035aa1a-4f19-4bf0-a0f8-cc7016bd4b9e"
      },
      "source": [
        "import sys\n",
        "print(sys.executable)\n",
        "print(sys.version)\n",
        "print(sys.version_info)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "/usr/bin/python3\n",
            "3.7.12 (default, Sep 10 2021, 00:21:48) \n",
            "[GCC 7.5.0]\n",
            "sys.version_info(major=3, minor=7, micro=12, releaselevel='final', serial=0)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MK7XbRYPKyef"
      },
      "source": [
        "1.1 Install required packages. Uncomment to execute once."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A1NCR0hmKva8"
      },
      "source": [
        "# !sudo apt-get update\n",
        "# !sudo apt-get install -y xvfb ffmpeg freeglut3-dev\n",
        "# !pip install -q 'gym==0.16.0'\n",
        "# !pip install 'imageio==2.4.0'\n",
        "# !pip install pyvirtualdisplay\n",
        "# !pip install tf-agents[reverb]\n",
        "# !pip install pyglet\n",
        "# !pip install ale-py"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FnnLx5h3K3Ys"
      },
      "source": [
        "1.2. Install Atari Roms to /usr/local/lib/python3.7/dist-packages/atari_py/atari_roms/. Uncomment to execute once."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OYt1LsN9HuQ1"
      },
      "source": [
        "# !wget http://www.atarimania.com/roms/Roms.rar\n",
        "# !pip install unrar\n",
        "# !unrar x Roms.rar\n",
        "# !mkdir rars\n",
        "# !mv HC\\ ROMS.zip  rars\n",
        "# !mv ROMS.zip  rars\n",
        "# !python -m atari_py.import_roms rars"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Aus2dmkKXtDO"
      },
      "source": [
        "1.3. Import packages. Sometimes it has to run twice."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ih721qQ2U-sl"
      },
      "source": [
        "import base64\n",
        "import imageio\n",
        "import IPython\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import numpy as np\n",
        "import PIL.Image\n",
        "import pyvirtualdisplay\n",
        "import reverb\n",
        "\n",
        "import gym\n",
        "import tensorflow as tf\n",
        "\n",
        "from tf_agents.agents.dqn import dqn_agent\n",
        "from tf_agents.drivers import py_driver\n",
        "from tf_agents.drivers.dynamic_step_driver import DynamicStepDriver\n",
        "from tf_agents.environments import suite_gym, suite_atari\n",
        "from tf_agents.environments import tf_py_environment\n",
        "from tf_agents.eval import metric_utils\n",
        "from tf_agents.metrics import tf_metrics\n",
        "from tf_agents.networks import sequential, q_network, network\n",
        "from tf_agents.policies import py_tf_eager_policy\n",
        "from tf_agents.policies import random_tf_policy\n",
        "from tf_agents.replay_buffers import TFUniformReplayBuffer\n",
        "from tf_agents.trajectories import trajectory\n",
        "from tf_agents.specs import tensor_spec\n",
        "from tf_agents.utils import common"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "id": "dnKwYTFXN8kb",
        "outputId": "2301f1d2-e255-4774-ac8e-3e1b13964471"
      },
      "source": [
        "gym.__version__"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            },
            "text/plain": [
              "'0.21.0'"
            ]
          },
          "metadata": {},
          "execution_count": 9
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Os2VUQOYXfxN"
      },
      "source": [
        "# list available environments\n",
        "# print(gym.envs.registry.all())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WIbEdOfRJRqc"
      },
      "source": [
        "Setup virtual display and helper class"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5bka8E1LJW4Z"
      },
      "source": [
        "# Set up a virtual display for rendering OpenAI gym environments.\n",
        "display = pyvirtualdisplay.Display(visible=0, size=(1400, 900)).start()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P463hJTKJSP3"
      },
      "source": [
        "def embed_mp4(filename):\n",
        "  \"\"\"Embeds an mp4 file in the notebook.\"\"\"\n",
        "  video = open(filename,'rb').read()\n",
        "  b64 = base64.b64encode(video)\n",
        "  tag = '''\n",
        "  <video width=\"640\" height=\"480\" controls>\n",
        "    <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\">\n",
        "  Your browser does not support the video tag.\n",
        "  </video>'''.format(b64.decode())\n",
        "\n",
        "  return IPython.display.HTML(tag)\n",
        "\n",
        "def create_policy_eval_video(policy, filename, num_episodes=5, fps=30, max_steps=-1):\n",
        "  filename = filename + \".mp4\"\n",
        "  with imageio.get_writer(filename, fps=fps) as video:\n",
        "    for _ in range(num_episodes):\n",
        "      time_step = eval_env.reset()\n",
        "      video.append_data(eval_py_env.render())\n",
        "      n_step = 0\n",
        "      while not time_step.is_last():\n",
        "        action_step = policy.action(time_step)\n",
        "        time_step = eval_env.step(action_step.action)\n",
        "        video.append_data(eval_py_env.render())\n",
        "        n_step += 1\n",
        "        if (n_step > max_steps) & (max_steps > 0):\n",
        "          break\n",
        "  return embed_mp4(filename)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "77AIHJeBJIfQ"
      },
      "source": [
        "## Environment\n",
        "\n",
        "Load Atari Environment"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mKZdbUONYR_m"
      },
      "source": [
        "#env_name = 'BreakoutNoFrameskip-v4'\n",
        "env_name = 'SpaceInvaders-v0'\n",
        "env = suite_gym.load(env_name)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Knvd7UvHl7DH"
      },
      "source": [
        "This is how the game looks like."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 227
        },
        "id": "ihuyn_MfR4QN",
        "outputId": "23d0ed60-9fa2-4215-f2e0-ac662e0ff7e1"
      },
      "source": [
        "env.reset()\n",
        "PIL.Image.fromarray(env.render())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAKAAAADSCAIAAABCR1ywAAADn0lEQVR4nO3dsa7TVhgHcF/EM3QqDJ0qVV2YeIcuFUwsPEjUscqDsMPWd2BiqZA6dejlQRiCbq3cOD4mx/6Ov/P7DYhEf4xPPn9x7OM4wwAAAAAAe3A3fvDizxez/+DTH59WW5lza6/Pu+PL2czbw8fvXv5Sa6zP3Xxk2tICtLYBLbW0AC1sQJMdPFWYqA5eY33GBZgqTFQH11qfah1cUoDWNqCllhaghQ1IB3+jgy/QwXWfX4MO/kYHX6CD6z6/BsfBMxwHz3AcXJ4HAAAAAGCR4/GZfB5nw5sdbW/5fTsN72GQha9OP/ndGw+1ZLS95WPdNB88djbUw+FevgVPqizlNNrTIE9/Xt+0e8sHqtPBj4d3fYvuLR+oTgeTXGuHJa3lA1Xo4IuHDVfG3FseAAAA2Moqs0klJ2Z7y0epOZs09VA+ULXJhoetuHBz7i0fpcJb9NT2OzXy3vK719rJ/dbysZ7WWtDhcD++zkG+ESb8mdPaW2Jr+Vg6ODkFBgAAAPjfxbN0s6f6+snHciYruWoFPjv5Lt+IavPBw/Kh9pbfsYcps8K5s97ySRwX3nWmt3wIH7KSU2DKtPaptbX8jj3eFV3fOfWWBwAAALbiHh0b5aO4R8cW+UDVbic8FN/ivrd8LLf03yIfqM5b9NnwZkfbWz6D1qbnWstHMeFPgdY+tbaWD6SDmXNx+y05zOgkDwAAAGzFFR0b5aO4omOLfKCaV3QMw3A43JdfEdFJPpbJhuRq3oRlWL4h95bfq9M4T1+TLRlzb/ndGw+y/AXqJx/IPjg5BU6u5q0MxxcalhxKdpUHAAAA9mXp8X5v+RCu6NgiH6jyFR3Xn+wzH8vP6myU37fW3hJbywcyXUiB1q6gaC2/b629mq3lY3mLZk5rn1dbywMAAAAAAAAAAAAAAPSq2q+u3OKv1z8//P239/9YfkW+fJZcfIHHm//jh5Z/o/gCsyoFTk6Bk1Pg5BQ4OQVOToGTCy7wxaPGioeSe1/+7XRwcgqcnAInp8DJKXBylX8B/PuM51DX+Ai69+XfQgcDAAAAAA1o4rtJUd4dX85m3h4+brAm63EuOrmuO3jKuLN1ME1rYj44Ssk+eO90cHL2wRfYB7Mb9sHJ6eDkZvbBv7/5YZv1YCWTBa5Y2v9++XEYhuefv9Ra4H69+vWnYRg+/P3vZv/jUz2am31wcgqcnAInd2cfnJsOTk6Bk1Pg5BQ4OQVOToGTU+DkFDi5r/CCTwE5labXAAAAAElFTkSuQmCC\n",
            "text/plain": [
              "<PIL.Image.Image image mode=RGB size=160x210 at 0x7F465E882510>"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "yQ16RNKvT7ne",
        "outputId": "aa29e0a8-4406-413a-f689-78a631354db3"
      },
      "source": [
        "print('Observation Spec:')\n",
        "print(env.time_step_spec().observation)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Observation Spec:\n",
            "BoundedArraySpec(shape=(210, 160, 3), dtype=dtype('uint8'), name='observation', minimum=0, maximum=255)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4B4wMn0lUnYM",
        "outputId": "0762085e-8a35-41ca-b20c-82f87e76c188"
      },
      "source": [
        "print('Reward Spec:')\n",
        "print(env.time_step_spec().reward)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Reward Spec:\n",
            "ArraySpec(shape=(), dtype=dtype('float32'), name='reward')\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "nUP3hP8RX-9F",
        "outputId": "d3987ded-5fac-468b-8abe-0f694dbc07b8"
      },
      "source": [
        "print('Action Spec:')\n",
        "print(env.action_spec())"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Action Spec:\n",
            "BoundedArraySpec(shape=(), dtype=dtype('int64'), name='action', minimum=0, maximum=5)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "-tzG7H7vYO7S",
        "outputId": "521173df-d8df-4a7a-b135-7dfd997ff19b"
      },
      "source": [
        "env.unwrapped.get_action_meanings()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['NOOP', 'FIRE', 'RIGHT', 'LEFT', 'RIGHTFIRE', 'LEFTFIRE']"
            ]
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "W4pl3rdmOEgC"
      },
      "source": [
        "In the Atari Space_Invaders environment, the agent learns to control a laser cannon to fire at descending aliens. The goal is to defeat all the aliens while avoiding to be destroyed by them.\n",
        "\n",
        "* Observation has a shape of (210, 160, 3), which stands for 210 pixels long, 160 pixels wide, and RGB color channels. Each chanel is an integer value from 0 to 255. For example, a black pixel is (0,0,0), a white pixel is (255, 255, 255).\n",
        "* Reward is a scalar float value. Total rewards is the game score. No discount.\n",
        "* Action is a scalar integer with six possible values:\n",
        "  * 0 — Stand still\n",
        "  * 1 — Fire\n",
        "  * 2 -- Move Right\n",
        "  * 3 -- Move Left\n",
        "  * 4 -- Move Right and Fire\n",
        "  * 5 -- Move Left and Fire\n",
        "\n",
        "After we take an action, the environment moves to the next time step."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "04DW9TH4O1FT",
        "outputId": "d497714a-e0ce-4cc9-9057-1b2c4c79e53e"
      },
      "source": [
        "time_step = env.reset()\n",
        "print('Time step:')\n",
        "print(time_step.observation.shape)\n",
        "\n",
        "action = np.array(1, dtype=np.int32)\n",
        "\n",
        "next_time_step = env.step(action)\n",
        "print('Next time step:')\n",
        "print(next_time_step.observation.shape)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Time step:\n",
            "(210, 160, 3)\n",
            "Next time step:\n",
            "(210, 160, 3)\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EzfkAfAcvpu7"
      },
      "source": [
        "The first thing is to pre-process or downsample the game screen. TF-Agents offers standard image preprocessing as\n",
        "* Frame skipping (defaults to 4).\n",
        "* Terminal signal when a life is lost (off by default).\n",
        "* Grayscale and max-pooling of the last two frames.\n",
        "* Downsample the screen to a square image (defaults to 84x84).\n",
        "* Frame stacking to tell the direction and speed of the ball."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RRBYI6hzKGsA"
      },
      "source": [
        "ATARI_FRAME_SKIP = 4\n",
        "max_episode_frames = ATARI_FRAME_SKIP * 50_000\n",
        "\n",
        "train_py_env = suite_atari.load(\n",
        "    env_name,\n",
        "    max_episode_steps=max_episode_frames / ATARI_FRAME_SKIP,\n",
        "    gym_env_wrappers=suite_atari.DEFAULT_ATARI_GYM_WRAPPERS_WITH_STACKING)\n",
        "eval_py_env = suite_atari.load(\n",
        "    env_name,\n",
        "    max_episode_steps=max_episode_frames / ATARI_FRAME_SKIP,\n",
        "    gym_env_wrappers=suite_atari.DEFAULT_ATARI_GYM_WRAPPERS_WITH_STACKING)\n",
        "\n",
        "train_env = tf_py_environment.TFPyEnvironment(train_py_env)\n",
        "eval_env = tf_py_environment.TFPyEnvironment(eval_py_env)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wWON8a09KMg5"
      },
      "source": [
        "Taste the game environment with a random policy. It does not play well.\n",
        "\n",
        "The random policy is like an infant, who plays with the joystick and does meaningless moves. The remainder of the notebook is to train her how to play the game. Come back and compare with this moment to see how she grows."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5T0K4bIGKPrI"
      },
      "source": [
        "random_policy = random_tf_policy.RandomTFPolicy(train_env.time_step_spec(), train_env.action_spec())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 538
        },
        "id": "fjCpyU1XKVJ9",
        "outputId": "ce3cf701-eff6-4c19-ecc6-6d3df2b2cc37"
      },
      "source": [
        "create_policy_eval_video(random_policy, \"random-agent\", num_episodes=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:root:IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (210, 160) to (224, 160) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to None (risking incompatibility). You may also see a FFMPEG warning concerning speedloss due to data not being aligned.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <video width=\"640\" height=\"480\" controls>\n",
              "    <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
              "  Your browser does not support the video tag.\n",
              "  </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 22
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WzkKtk3XKeTw"
      },
      "source": [
        "## Agent\n",
        "\n",
        "It defines the DQN agent to be trained.\n",
        "\n",
        "At the heart of a DQN Agent is a `QNetwork`, a neural network model that can learn to predict `QValues` (expected returns) for all actions, given an observation from the environment.\n",
        "\n",
        "The QNet is a convolutional neural network (CNN) illustrated as below.\n",
        "\n",
        "![DQN](https://leonardoaraujosantos.gitbook.io/~/files/v0/b/gitbook-28427.appspot.com/o/assets%2F-LvMRntv-nKvtl7WOpCz%2F-LvMRp9FltcwEeVxPYFs%2F-LvMRsnabIKrofQLFbYP%2FDQNBreakoutBlocks.png?generation=1575572714769936&alt=media)\n",
        "\n",
        "[Figure source](https://leonardoaraujosantos.gitbook.io/artificial-inteligence/)\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "S7W1VfUHqjgz"
      },
      "source": [
        "CNN is widely used in image recognition. Here the game screen has a shape of (210, 160, 3), which stands for 210 pixels long, 160 pixels wide, and RGB color channels. DQN downsamples the pixel to 84 x 84 and convert the RGB colors to grayscale. Then it stacks 4 frames together in order to tell the direction and velocity of moving objects. Therefore the input is 84x84x4."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "_8foWje8q7er",
        "outputId": "e4509090-367f-4987-f41b-af7392ecaa6e"
      },
      "source": [
        "train_py_env.observation_spec().shape        # (84x84) x 4 frames"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(84, 84, 4)"
            ]
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TrtqdpljKqSQ"
      },
      "source": [
        "# https://keras.io/examples/rl/deep_q_network_breakout/\n",
        "# Define a Q network with three convolutional layers and a fully connected layer\n",
        "action_tensor_spec = tensor_spec.from_spec(train_env.action_spec())\n",
        "num_actions = action_tensor_spec.maximum - action_tensor_spec.minimum + 1\n",
        "observation_spec = tensor_spec.from_spec(train_env.observation_spec())    # (84, 84, 4) four gray frames stacking       \n",
        "\n",
        "# preprocessing from uint8 color code between 0 and 255 to a float32 between 0 and 1.\n",
        "layer0 = tf.keras.layers.Lambda(lambda obs: tf.cast(obs, np.float32) / 255.)\n",
        "layer1 = tf.keras.layers.Conv2D(filters=32, kernel_size=(8, 8), strides = (4, 4), activation='relu')\n",
        "layer2 = tf.keras.layers.Conv2D(filters=64, kernel_size=(4, 4), strides = (2, 2), activation='relu')\n",
        "layer3 = tf.keras.layers.Conv2D(filters=64, kernel_size=(3, 3), strides = (1, 1), activation='relu')\n",
        "layer4 = tf.keras.layers.Flatten()\n",
        "layer5 = tf.keras.layers.Dense(512, activation='relu')\n",
        "layer6 = tf.keras.layers.Dense(num_actions, activation='linear') # action layer\n",
        "\n",
        "q_net = sequential.Sequential([layer0, layer1, layer2, layer3, layer4, layer5, layer6])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "JEs_VA2ZKuO3",
        "outputId": "bbdc8c69-0f46-4c2a-ee79-a2de9a3900e9"
      },
      "source": [
        "q_net.build(input_shape=observation_spec.shape)\n",
        "q_net.summary()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Model: \"sequential\"\n",
            "_________________________________________________________________\n",
            "Layer (type)                 Output Shape              Param #   \n",
            "=================================================================\n",
            "lambda (Lambda)              multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "conv2d (Conv2D)              multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "conv2d_1 (Conv2D)            multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "conv2d_2 (Conv2D)            multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "flatten (Flatten)            multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "dense (Dense)                multiple                  0 (unused)\n",
            "_________________________________________________________________\n",
            "dense_1 (Dense)              multiple                  0 (unused)\n",
            "=================================================================\n",
            "Total params: 0\n",
            "Trainable params: 0\n",
            "Non-trainable params: 0\n",
            "_________________________________________________________________\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jNDz796RyfGp"
      },
      "source": [
        "Now use `tf_agents.agents.dqn.dqn_agent` to instantiate a `DqnAgent`. In addition to the `time_step_spec`, `action_spec` and the QNetwork, the agent constructor also requires an optimizer, a loss function, and an integer step counter.\n",
        "\n",
        "The hyper-parameters follow [Hands-on Machine Learning by Aurélien Géron 2019](https://www.oreilly.com/library/view/hands-on-machine-learning/9781492032632/)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "O3fjg3_HyilK"
      },
      "source": [
        "global_step = tf.compat.v1.train.get_or_create_global_step()\n",
        "#train_step = tf.Variable(0)\n",
        "update_period = 4 # train the model every 4 steps\n",
        "optimizer = tf.keras.optimizers.RMSprop(lr=2.5e-4, rho=0.95, momentum=0.0,\n",
        "                                     epsilon=0.00001, centered=True)\n",
        "epsilon_fn = tf.keras.optimizers.schedules.PolynomialDecay(\n",
        "    initial_learning_rate=1.0, # initial ε\n",
        "    decay_steps=250000 // update_period, # <=> 1,000,000 ALE frames\n",
        "    end_learning_rate=0.01) # final ε\n",
        "agent = dqn_agent.DqnAgent(train_env.time_step_spec(),\n",
        "                           train_env.action_spec(),\n",
        "                           q_network=q_net,\n",
        "                           optimizer=optimizer,\n",
        "                           target_update_period=2000, # <=> 32,000 ALE frames\n",
        "                           td_errors_loss_fn=tf.keras.losses.Huber(reduction=\"none\"),\n",
        "                           gamma=0.99, # discount factor\n",
        "                           train_step_counter=global_step,\n",
        "                           epsilon_greedy=lambda: epsilon_fn(global_step))\n",
        "agent.initialize()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1h2kWfJ5xyxA"
      },
      "source": [
        "Agents contain two policies:\n",
        "\n",
        "* agent.policy — The main policy that is used for evaluation and deployment.\n",
        "* agent.collect_policy — A second policy that is used for data collection."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vSt0sdQS4ss8"
      },
      "source": [
        "## Metrics\n",
        "\n",
        "The most common metric used to evaluate a policy is the average return. The return is the sum of rewards obtained while running a policy in an environment for an episode. Several episodes are run, creating an average return.\n",
        "\n",
        "The following function computes the average return of a policy, given the policy, environment, and a number of episodes."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fATYgTyA4uAL"
      },
      "source": [
        "def compute_avg_return(environment, policy, num_episodes=10, max_steps=-1):\n",
        "\n",
        "  total_return = 0.0\n",
        "  for _ in range(num_episodes):\n",
        "\n",
        "    time_step = environment.reset()\n",
        "    episode_return = 0.0\n",
        "    n_step = 0\n",
        "\n",
        "    while not time_step.is_last():\n",
        "      action_step = policy.action(time_step)\n",
        "      time_step = environment.step(action_step.action)\n",
        "      episode_return += time_step.reward\n",
        "      n_step += 1\n",
        "      if (n_step > max_steps) & (max_steps > 0):\n",
        "        break\n",
        "    \n",
        "    total_return += episode_return\n",
        "\n",
        "  avg_return = total_return / num_episodes\n",
        "  return avg_return.numpy()[0]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1Eq9mv-w44ab"
      },
      "source": [
        "Running this computation on the `random_policy` shows a baseline performance in the environment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4VziiEh6489E",
        "outputId": "d6ad5acd-2568-4564-e820-30f0720552fa"
      },
      "source": [
        "num_eval_episodes = 5\n",
        "compute_avg_return(eval_env, random_policy, num_eval_episodes)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "171.0"
            ]
          },
          "metadata": {},
          "execution_count": 28
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "zk5zCZSe5JHv"
      },
      "source": [
        "## Replay Buffer\n",
        "\n",
        "One original design of DQN is replay buffer. It collects the experience or transition tuple $(s, a, s', r)$ from not only current policy but also other policies. It then takes random mini-batches from the buffer.\n",
        "\n",
        "Replay buffer in TF-Agents consists of below components.\n",
        "1. driver -- explores the environment using a collect policy\n",
        "2. collect policy -- used by driver to interact with the environment\n",
        "3. observer -- receives trajectories or experiences from driver and save to replay buffer\n",
        "4. agent -- randomly pull experience from replay buffer and use the experience to train\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lBoLbXVp8WYK"
      },
      "source": [
        "replay_buffer = TFUniformReplayBuffer(\n",
        "    data_spec=agent.collect_data_spec,\n",
        "    batch_size=train_env.batch_size,\n",
        "    max_length=100_000)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pyG9-FF4_moS"
      },
      "source": [
        "replay_buffer_observer = replay_buffer.add_batch"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BlgCyCODAPk0"
      },
      "source": [
        "To start, initialize the replay buffer with some random experiences. The replay buffer is FIFO. As new experiences arrive, they will overwrite old experiences.\n",
        "\n",
        "It takes a couple of minutes to fill 20,000 steps."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Blt19yw_8L7"
      },
      "source": [
        "train_env.reset()\n",
        "\n",
        "init_driver = DynamicStepDriver(\n",
        "    train_env,\n",
        "    random_policy,\n",
        "    observers=[replay_buffer.add_batch],\n",
        "    num_steps=20_000) # <=> 80,000 ALE frames\n",
        "final_time_step, final_policy_state = init_driver.run()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2iY2lGo3EaSr"
      },
      "source": [
        "For information purposes, sample a batch of trajectories from the replay buffer and examine how they look like.\n",
        "\n",
        "Below it samples 2 trajectories; each has three steps; each step contains a 84x84x4 observation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CiWwEQjKDyrh"
      },
      "source": [
        "trajectories, buffer_info = replay_buffer.get_next(sample_batch_size=2, num_steps=3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "95mfW2iXD375",
        "outputId": "004e5152-24fe-4057-f783-8d6b1c1137e7"
      },
      "source": [
        "trajectories.observation.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([2, 3, 84, 84, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "zmOO8T7CIcwx",
        "outputId": "5a1b050a-b961-402b-c344-bd31eb454168"
      },
      "source": [
        "from tf_agents.trajectories.trajectory import to_transition\n",
        "time_steps, action_steps, next_time_steps = to_transition(trajectories)\n",
        "time_steps.observation.shape"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "TensorShape([2, 2, 84, 84, 4])"
            ]
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iQfR3sReF0V7"
      },
      "source": [
        "The agent needs access to the replay buffer. This is provided by creating an iterable tf.data.Dataset pipeline which will feed data to the agent.\n",
        "\n",
        "Each row of the replay buffer only stores a single observation step. But since the DQN Agent needs both the current and next observation to compute the loss, the dataset pipeline will sample two adjacent rows for each item in the batch (`num_steps=2`)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GTqenYqT9qvT"
      },
      "source": [
        "dataset = replay_buffer.as_dataset(\n",
        "    num_parallel_calls=3,\n",
        "    sample_batch_size=32,\n",
        "    num_steps=2).prefetch(3)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MOfe0JwoINaR"
      },
      "source": [
        "iterator = iter(dataset)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g7X9Ihu7Th6n"
      },
      "source": [
        "## Training the agent\n",
        "\n",
        "Now it is ready to train the agent. \n",
        "\n",
        "Set num_iterations to 5_000 for testing. 1_000_000 takes days.\n",
        "\n",
        "[Save Model](https://www.tensorflow.org/agents/tutorials/10_checkpointer_policysaver_tutorial)\n",
        "\n",
        "[Colab timeout](https://research.google.com/colaboratory/faq.html#idle-timeouts)\n",
        "\n",
        "It needs to periodically save the model in order to continue the training process after Colab disconnection. To save and reload agent status, including replay buffer, use Checkpointer.\n",
        "\n",
        "In the end, we can just save the policy using PolicySaver."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I06T5RXIHS0L"
      },
      "source": [
        "num_iterations = 100_000   # less intelligence, more persistance; 24x7 player\n",
        "save_interval = 100_000\n",
        "eval_interval = 50_000\n",
        "log_interval = 5_000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3nHDKUI7ImqB"
      },
      "source": [
        "# Create a driver to collect experience.\n",
        "collect_driver = DynamicStepDriver(\n",
        "    train_env,\n",
        "    agent.collect_policy,\n",
        "    observers=[replay_buffer_observer],\n",
        "    num_steps=update_period) # collect 4 steps for each training iteration"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g7J8ITpXFp-U"
      },
      "source": [
        "#from tf_agents.policies import PolicySaver\n",
        "import os\n",
        "import io\n",
        "import tempfile\n",
        "import shutil\n",
        "import zipfile\n",
        "import numpy as np\n",
        "from google.colab import files\n",
        "\n",
        "tempdir = os.getenv(\"TEST_TMPDIR\", tempfile.gettempdir())"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "n0VbctgGFtUz"
      },
      "source": [
        "def create_zip_file(dirname, base_filename):\n",
        "  return shutil.make_archive(base_filename, 'zip', dirname)\n",
        "\n",
        "def save_checkpoint_to_local():\n",
        "  train_checkpointer.save(global_step)\n",
        "  # add returns to checkpoint_dir\n",
        "  np.savetxt(os.path.join(checkpoint_dir, 'returns.txt'), returns, delimiter=',')\n",
        "  checkpoint_zip_filename = create_zip_file(checkpoint_dir, os.path.join(tempdir, 'exported_cp'))\n",
        "  # Privacy and security -> Site Settings -> Automatic downloads\n",
        "  files.download(checkpoint_zip_filename) # try again if this fails: https://github.com/googlecolab/colabtools/issues/469\n",
        "\n",
        "def upload_and_unzip_file_to(dirname):\n",
        "  if files is None:\n",
        "    return\n",
        "  uploaded = files.upload()\n",
        "  for fn in uploaded.keys():\n",
        "    print('User uploaded file \"{name}\" with length {length} bytes'.format(\n",
        "        name=fn, length=len(uploaded[fn])))\n",
        "    shutil.rmtree(dirname)\n",
        "    zip_files = zipfile.ZipFile(io.BytesIO(uploaded[fn]), 'r')\n",
        "    zip_files.extractall(dirname)\n",
        "    zip_files.close()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ps0HVyvgFzGh"
      },
      "source": [
        "checkpoint_dir = os.path.join(tempdir, 'checkpoint')\n",
        "train_checkpointer = common.Checkpointer(\n",
        "    ckpt_dir=checkpoint_dir,\n",
        "    max_to_keep=1,\n",
        "    agent=agent,\n",
        "    policy=agent.policy,\n",
        "    replay_buffer=replay_buffer,\n",
        "    global_step=global_step\n",
        ")"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EG7Xl2UHJxOs"
      },
      "source": [
        "To [keep Colab running](https://stackoverflow.com/questions/57113226/how-to-prevent-google-colab-from-disconnecting).\n",
        "\n",
        "function ConnectButton(){\n",
        "    console.log(\"Connect pushed\"); \n",
        "    document.querySelector(\"#top-toolbar > colab-connect-button\").shadowRoot.querySelector(\"#connect\").click() \n",
        "}\n",
        "\n",
        "var colab = setInterval(ConnectButton,60000);\n",
        "clearInterval(colab)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "sz6bpOunG4CL",
        "outputId": "baf73e04-c65a-4929-cf24-b65160ff3fb5"
      },
      "source": [
        "# (Optional) Optimize by wrapping some of the code in a graph using TF function.\n",
        "collect_driver.run = common.function(collect_driver.run)\n",
        "agent.train = common.function(agent.train)\n",
        "\n",
        "# Reset the train step.\n",
        "agent.train_step_counter.assign(0)\n",
        "\n",
        "# Evaluate the agent's policy once before training.\n",
        "avg_return = compute_avg_return(eval_env, agent.policy, num_eval_episodes)\n",
        "returns = np.array([avg_return])\n",
        "\n",
        "# Reset the environment.\n",
        "time_step = None\n",
        "policy_state = agent.collect_policy.get_initial_state(train_env.batch_size)\n",
        "\n",
        "step = 0\n",
        "while True:\n",
        "    # Collect a few steps using collect_policy and save to the replay buffer.\n",
        "    time_step, policy_state = collect_driver.run(time_step, policy_state)\n",
        "\n",
        "    # Sample a batch of data from the buffer and update the agent's network.\n",
        "    experience, unused_info = next(iterator)\n",
        "    train_loss = agent.train(experience).loss\n",
        "\n",
        "    step = agent.train_step_counter.numpy()\n",
        "    print(f'\\r step {step}', end='')\n",
        "\n",
        "    if step % log_interval == 0:\n",
        "        print('step = {0}: loss = {1}'.format(step, train_loss))\n",
        "\n",
        "    if step % eval_interval == 0:\n",
        "        avg_return = compute_avg_return(eval_env, agent.policy, num_eval_episodes)\n",
        "        print('step = {0}: Average Return = {1}'.format(step, avg_return))\n",
        "        returns = np.append(returns, avg_return)\n",
        "\n",
        "    # if step % save_interval == 0:\n",
        "    #     save_checkpoint_to_local()\n",
        "\n",
        "    if step > num_iterations:\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "metadata": {
            "tags": null
          },
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py:1096: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
            "Instead of:\n",
            "results = tf.foldr(fn, elems, back_prop=False)\n",
            "Use:\n",
            "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
          ]
        },
        {
          "metadata": {
            "tags": null
          },
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "WARNING:tensorflow:From /usr/local/lib/python3.7/dist-packages/tensorflow/python/util/dispatch.py:1096: calling foldr_v2 (from tensorflow.python.ops.functional_ops) with back_prop=False is deprecated and will be removed in a future version.\n",
            "Instructions for updating:\n",
            "back_prop=False is deprecated. Consider using tf.stop_gradient instead.\n",
            "Instead of:\n",
            "results = tf.foldr(fn, elems, back_prop=False)\n",
            "Use:\n",
            "results = tf.nest.map_structure(tf.stop_gradient, tf.foldr(fn, elems))\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " step 5000step = 5000: loss = 0.608530580997467\n",
            " step 10000step = 10000: loss = 1.491654396057129\n",
            " step 15000step = 15000: loss = 1.0811423063278198\n",
            " step 20000step = 20000: loss = 0.04874517768621445\n",
            " step 25000step = 25000: loss = 1.1065270900726318\n",
            " step 30000step = 30000: loss = 0.08628454804420471\n",
            " step 35000step = 35000: loss = 0.7659016847610474\n",
            " step 40000step = 40000: loss = 1.0400705337524414\n",
            " step 45000step = 45000: loss = 2.0612244606018066\n",
            " step 50000step = 50000: loss = 0.8223446607589722\n",
            "step = 50000: Average Return = 245.0\n",
            " step 55000step = 55000: loss = 1.7679486274719238\n",
            " step 60000step = 60000: loss = 1.2738096714019775\n",
            " step 65000step = 65000: loss = 2.466463565826416\n",
            " step 70000step = 70000: loss = 0.8637232780456543\n",
            " step 75000step = 75000: loss = 2.239035129547119\n",
            " step 80000step = 80000: loss = 0.8663248419761658\n",
            " step 85000step = 85000: loss = 1.6288963556289673\n",
            " step 90000step = 90000: loss = 3.173646926879883\n",
            " step 95000step = 95000: loss = 1.4633464813232422\n",
            " step 100000step = 100000: loss = 2.337794065475464\n",
            "step = 100000: Average Return = 365.0\n",
            " step 100001"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "08YwMwPgSWMN",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "outputId": "fcac1cce-bb76-4820-e025-357b9700ec20"
      },
      "source": [
        "save_checkpoint_to_local()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_677f0cef-1d57-44e2-8ff7-64c20ce91535\", \"exported_cp.zip\", 191031536)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LWph3mD8qPEt"
      },
      "source": [
        "Upload and continue after Colab is disconnected."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xjj6WBqOzQXs"
      },
      "source": [
        "!mkdir -p $checkpoint_dir"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mhlQiYxYuIpk"
      },
      "source": [
        "upload_and_unzip_file_to(checkpoint_dir)\n",
        "train_checkpointer.initialize_or_restore()\n",
        "global_step = tf.compat.v1.train.get_global_step()\n",
        "returns = np.loadtxt(os.path.join(checkpoint_dir, 'returns.txt'), delimiter=',', dtype=np.float32)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oW-Gbt4Zci_E"
      },
      "source": [
        "remove uploaded file"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8mm_yXRMVOtS"
      },
      "source": [
        "!rm exported_cp.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pSySLtejsWo6"
      },
      "source": [
        "Continue the training. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cCKjC-nlRvW7"
      },
      "source": [
        "num_iterations = 200_000          # increase 100_000 each time, to 1_000_0000"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "KybMgrdfQT7T",
        "outputId": "ac173de6-70e4-4e71-96af-611c182274af"
      },
      "source": [
        "while True:\n",
        "    # Collect a few steps using collect_policy and save to the replay buffer.\n",
        "    time_step, policy_state = collect_driver.run(time_step, policy_state)\n",
        "\n",
        "    # Sample a batch of data from the buffer and update the agent's network.\n",
        "    experience, unused_info = next(iterator)\n",
        "    train_loss = agent.train(experience).loss\n",
        "\n",
        "    step = agent.train_step_counter.numpy()\n",
        "    print(f'\\r step {step}', end='')\n",
        "\n",
        "    if step % log_interval == 0:\n",
        "        print('step = {0}: loss = {1}'.format(step, train_loss))\n",
        "\n",
        "    if step % eval_interval == 0:\n",
        "        avg_return = compute_avg_return(eval_env, agent.policy, num_eval_episodes)\n",
        "        print('step = {0}: Average Return = {1}'.format(step, avg_return))\n",
        "        returns = np.append(returns, avg_return)\n",
        "\n",
        "    # if step % save_interval == 0:\n",
        "    #     save_checkpoint_to_local()\n",
        "\n",
        "    if step > num_iterations:\n",
        "        break"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            " step 105000step = 105000: loss = 1.713509440422058\n",
            " step 110000step = 110000: loss = 4.5312604904174805\n",
            " step 115000step = 115000: loss = 2.102066993713379\n",
            " step 120000step = 120000: loss = 3.047064781188965\n",
            " step 125000step = 125000: loss = 2.2205536365509033\n",
            " step 130000step = 130000: loss = 3.136992931365967\n",
            " step 135000step = 135000: loss = 8.079166412353516\n",
            " step 140000step = 140000: loss = 1.7076475620269775\n",
            " step 145000step = 145000: loss = 1.7515592575073242\n",
            " step 150000step = 150000: loss = 2.315495252609253\n",
            "step = 150000: Average Return = 493.0\n",
            " step 155000step = 155000: loss = 2.5497970581054688\n",
            " step 160000step = 160000: loss = 3.640261173248291\n",
            " step 165000step = 165000: loss = 2.2458770275115967\n",
            " step 170000step = 170000: loss = 3.233553409576416\n",
            " step 175000step = 175000: loss = 5.8226704597473145\n",
            " step 180000step = 180000: loss = 3.067084789276123\n",
            " step 185000step = 185000: loss = 2.470966339111328\n",
            " step 190000step = 190000: loss = 3.1095316410064697\n",
            " step 195000step = 195000: loss = 2.8291192054748535\n",
            " step 200000step = 200000: loss = 3.8037238121032715\n",
            "step = 200000: Average Return = 408.0\n",
            " step 200001"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "id": "3ttQla_ESbpz",
        "outputId": "b716716e-92f8-49f7-8644-6bbe5392b90a"
      },
      "source": [
        "save_checkpoint_to_local()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_9ac480bc-a07c-4c6f-960a-68c0d23ebf5a\", \"exported_cp.zip\", 188040447)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fG85FIpkT-PI"
      },
      "source": [
        "In the end, save the lightweighted policy to play the game."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "jnuXzfm4UEDQ",
        "outputId": "1059d61a-e6be-4e96-b423-6f270019d214"
      },
      "source": [
        "from tf_agents.policies import policy_saver\n",
        "\n",
        "policy_dir = os.path.join(tempdir, 'policy')\n",
        "tf_policy_saver = policy_saver.PolicySaver(agent.policy)\n",
        "\n",
        "tf_policy_saver.save(policy_dir)\n",
        "policy_zip_filename = create_zip_file(policy_dir, os.path.join(tempdir, 'exported_policy'))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:absl:Function `function_with_signature` contains input name(s) 0/step_type, 0/reward, 0/discount, 0/observation with unsupported characters which will be renamed to step_type, reward, discount, observation in the SavedModel.\n",
            "WARNING:absl:Found untraced functions such as sequential_layer_call_fn, sequential_layer_call_and_return_conditional_losses, sequential_layer_call_fn, sequential_layer_call_and_return_conditional_losses, sequential_layer_call_and_return_conditional_losses while saving (showing 5 of 40). These functions will not be directly callable after loading.\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "INFO:tensorflow:Assets written to: /tmp/policy/assets\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "INFO:tensorflow:Assets written to: /tmp/policy/assets\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        },
        "id": "WPm0iLE133ei",
        "outputId": "8d8f8f16-3346-4678-9f30-02e0392e7f13"
      },
      "source": [
        "files.download(policy_zip_filename)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "application/javascript": [
              "download(\"download_8cf17be3-b8e2-45b9-9bd4-ae4ed44e7c1a\", \"exported_policy.zip\", 6290197)"
            ],
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UIfM8hyPVVcT"
      },
      "source": [
        "## Evaluation\n",
        "\n",
        "Load the trained policy and saved average return.\n",
        "\n",
        "A trained policy is saved at https://github.com/letianzj/QuantResearch/blob/master/ml/atari_policy.zip"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "QXDaNLqtVG_0"
      },
      "source": [
        "# upload_and_unzip_file_to(policy_dir)       # wget from github and unzip\n",
        "# saved_policy = tf.saved_model.load(policy_dir)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8bC8WbugVfkp"
      },
      "source": [
        "The average return is expected to increase over training iterations.\n",
        "\n",
        "Here num_iterations = 200_000; eval_interval = 50_000."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j1ic_ZD6_1LP",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 300
        },
        "outputId": "4fcd3eda-59bb-471e-9221-504012a83bcd"
      },
      "source": [
        "iterations = range(0, num_iterations + 1, eval_interval)\n",
        "plt.plot(iterations, returns)\n",
        "plt.ylabel('Average Return')\n",
        "plt.xlabel('Iterations')\n",
        "plt.ylim(top=550)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(232.6, 550.0)"
            ]
          },
          "metadata": {},
          "execution_count": 57
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ]
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fFLynDBlV4SB"
      },
      "source": [
        "See how the trained agent plays."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5K9eFPrRVxtn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 538
        },
        "outputId": "acc3dbda-673a-4019-9a3c-fc6c5dc439b9"
      },
      "source": [
        "create_policy_eval_video(agent.policy, \"trained-agent\", num_episodes=1)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "WARNING:root:IMAGEIO FFMPEG_WRITER WARNING: input image is not divisible by macro_block_size=16, resizing from (210, 160) to (224, 160) to ensure video compatibility with most codecs and players. To prevent resizing, make your input image divisible by the macro_block_size or set the macro_block_size to None (risking incompatibility). You may also see a FFMPEG warning concerning speedloss due to data not being aligned.\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/html": [
              "\n",
              "  <video width=\"640\" height=\"480\" controls>\n",
              "    <source src=\"data:video/mp4;base64,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\" type=\"video/mp4\">\n",
              "  Your browser does not support the video tag.\n",
              "  </video>"
            ],
            "text/plain": [
              "<IPython.core.display.HTML object>"
            ]
          },
          "metadata": {},
          "execution_count": 62
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "C6vz9Xiq2Jff"
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}